package gacha

import (
	"encoding/json"
	"io"
	"os"
	"time"
)

func loadJson(uid string) map[string][]GaCha {
	b, err := os.ReadFile(dataPath(uid) + `data.json`)
	if err != nil {
		return nil
	}
	data := &map[string][]GaCha{}
	err = json.Unmarshal(b, data)
	if err != nil {
		return nil
	}
	return *data
}

func saveJson(uid string, data map[string][]GaCha, ch *Ch) {
	p := dataPath(uid)
	if !fileExists(p) {
		err := os.MkdirAll(p, os.ModePerm)
		if err != nil {
			ch.sendError(`在创建用户数据存储目录时出错：` + err.Error())
			return
		}
	}
	f := p + "data.json"
	if fileExists(f) {
		ch.sendMessage(`正在对已存储的数据进行备份`)
		bf := p + "data_" + time.Now().Format(`20060102150405`) + ".json"
		err := copyFile(bf, f)
		if err != nil {
			ch.sendError(`在创建数据备份时出错，已停止存储数据：` + err.Error())
			return
		} else {
			ch.sendMessage(`旧数据已备份到` + bf)
		}
	}
	b, err := json.Marshal(data)
	if err != nil {
		ch.sendError(`在存储数据时序列化错误，已停止存储数据：` + err.Error())
		return
	}

	src, err := os.OpenFile(f, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0644)
	if err != nil {
		ch.sendError(`在存储数据时创建或打开文件错误，已停止存储数据：` + err.Error())
		return
	}
	defer func(src *os.File) {
		_ = src.Close()
	}(src)
	n, err := src.Write(b)
	if err == nil && n < len(data) {
		err = io.ErrShortWrite
	}
	if err != nil {
		ch.sendError(`在存储数据时写入文件错误，已删除出错的数据：` + err.Error())
		_ = os.Remove(f)
		return
	} else {
		ch.sendMessage(`数据已存储到` + f)
	}
}

func copyFile(dstName, srcName string) (err error) {
	src, err := os.Open(srcName)
	if err != nil {
		return
	}
	defer func(src *os.File) {
		_ = src.Close()
	}(src)

	dst, err := os.OpenFile(dstName, os.O_WRONLY|os.O_CREATE, 0644)
	if err != nil {
		return
	}
	defer func(dst *os.File) {
		_ = dst.Close()
	}(dst)

	_, err = io.Copy(dst, src)
	return
}

func dataPath(uid string) string {
	return `./data/` + uid + `/`
}

func fileExists(name string) bool {
	if _, err := os.Stat(name); err != nil {
		if os.IsNotExist(err) {
			return false
		}
	}
	return true
}
